"""
数据源服务
"""
import uuid
from loguru import logger
from services.redis_service import RedisService
from services.dify_service import DifyService
from models.database_models import DataSourceRepository, DatabaseSetup

class DataSourceService:
    """数据源服务类，负责获取和存储数据源"""
    
    def __init__(self):
        """初始化服务"""
        self.redis_service = RedisService()
        self.dify_service = DifyService()
        self.db_repository = DataSourceRepository()
        
        # 确保数据库表已创建
        self._init_database()
    
    def _init_database(self):
        """初始化数据库"""
        try:
            db_setup = DatabaseSetup()
            db_setup.create_tables()
            logger.info("数据库初始化完成")
        except Exception as e:
            logger.error(f"数据库初始化失败: {e}")
            raise
    
    def get_data_sources(self, query_text):
        """
        获取数据源信息
        
        Args:
            query_text: 用户查询文本
        
        Returns:
            dict: 处理结果
        """
        try:
            # 记录请求
            logger.info(f"接收到数据源请求: {query_text}")
            
            # 检查Redis缓存
            redis_key = f"data_source:{query_text}"
            cached_data = self.redis_service.get_data(redis_key)
            
            if cached_data:
                logger.info(f"从Redis缓存获取到数据源信息: {redis_key}")
                return {
                    'success': True,
                    'message': '从缓存获取数据源成功',
                    'data': cached_data,
                    'from_cache': True
                }
            
            # 从Dify API获取数据
            logger.info(f"缓存未命中，从Dify API获取数据源: {query_text}")
            dify_result = self.dify_service.get_data_sources(query_text)
            
            if not dify_result:
                logger.error("从Dify API获取数据源失败")
                return {
                    'success': False,
                    'message': '从Dify API获取数据源失败',
                    'data': None
                }
            
            # 保存到数据库
            self._save_to_database(dify_result)
            
            # 缓存到Redis
            self.redis_service.set_data(redis_key, dify_result)
            
            return {
                'success': True,
                'message': '获取数据源成功',
                'data': dify_result,
                'from_cache': False
            }
        except Exception as e:
            logger.error(f"获取数据源过程中发生错误: {e}")
            return {
                'success': False,
                'message': f'处理过程中发生错误: {str(e)}',
                'data': None
            }
    
    def _save_to_database(self, data):
        """
        保存数据到数据库
        
        Args:
            data: 要保存的数据
        """
        try:
            # 保存任务基本信息
            if 'task_data' in data:
                task_id = self.db_repository.save_task(data['task_data'])
                logger.info(f"已保存任务基本信息，任务ID: {task_id}")
                
                # 保存检索条件
                if 'retrieval_conditions' in data and data['retrieval_conditions']:
                    data['retrieval_conditions']['task_id'] = task_id
                    self.db_repository.save_retrieval_conditions(data['retrieval_conditions'])
                    logger.info(f"已保存检索条件信息，任务ID: {task_id}")
                
                # 保存爬取策略
                if 'scraping_strategies' in data and data['scraping_strategies']:
                    data['scraping_strategies']['task_id'] = task_id
                    self.db_repository.save_scraping_strategies(data['scraping_strategies'])
                    logger.info(f"已保存爬取策略信息，任务ID: {task_id}")
                
                # 保存授权信息
                if 'authorization_info' in data and data['authorization_info']:
                    data['authorization_info']['task_id'] = task_id
                    self.db_repository.save_authorization_info(data['authorization_info'])
                    logger.info(f"已保存授权信息，任务ID: {task_id}")
            else:
                logger.warning("数据中没有任务基本信息，无法保存到数据库")
        except Exception as e:
            logger.error(f"保存数据到数据库失败: {e}")
            raise 